import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description: 数组个数
 * User: DELL
 * Date: 2024-05-18
 * Time: 12:16
 */
public class Main6 {
    static int MOD = 1_000_000_007;

    /**
     * 因为本题是满足条件个数的题，结合题目，可以猜测到大概率是dp的题目
     * 而本题因为是三个元素相关联，不难想到定义dp如下：
     * dp[i][j][k] = 第i个元素为j，第i-1个元素为k时，满足条件数组的个数
     * 而本题dp的难点在于最后两个元素与前面元素有关联，无法处理，因此只能是
     * 在原有dp的基础上，先枚举锁定前两个元素，然后再进行dp，因为dp也记录了最后
     * 两个元素是啥，在进行返回值计算的时候，验证满足情况的再加上
     * 状态转移：dp[i][j][k] = sum(dp[i-1][k][x]) 其中（j，k，x）属于[0,bi-1],且其中必须有一个值等于 bi-1
     * 初始化：根据枚举的n0和n1，初始化dp[2][x][n1] = 1，其中满足（n0，n1，x）属于[0,b1],且其中必须有一个值等于 b1
     * 返回值： 针对dp[i][j][k]，加上验证后两个元素 j 和 k满足的情况
     *
     * @param args
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] B = new int[n];
        for (int i = 0; i < n; i++) {
            B[i] = scanner.nextInt();
        }
        int ans = 0;
        // 先枚举前两个元素
        for (int n0 = 0; n0 <= B[1]; n0++) {
            for (int n1 = 0; n1 <= B[1]; n1++) {
                // 开始dp
                int[][][] dp = new int[n][10][10];
                // 初始化
                for (int x = 0; x <= B[1]; x++) {
                    if (n0 == B[1] || n1 == B[1] || x == B[1]) {
                        dp[2][x][n1] = 1;
                    }
                }
                // 状态转移
                for (int i = 3; i < n; i++) {
                    for (int j = 0; j <= B[i - 1]; j++) {
                        for (int k = 0; k <= B[i - 1]; k++) {
                            if (j == B[i - 1] || k == B[i - 1]) {
                                for (int x = 0; x <= B[i - 1]; x++) {
                                    dp[i][j][k] += dp[i - 1][k][x];
                                    dp[i][j][k] %= MOD;
                                }
                            } else {
                                dp[i][j][k] += dp[i - 1][k][B[i - 1]];
                                dp[i][j][k] %= MOD;
                            }
                        }
                    }
                }
                // 加上满足条件的结果
                for (int j = 0; j <= B[n - 1]; j++) {
                    for (int k = 0; k <= B[n - 1]; k++) {
                        if (getMax(n0, j, k) == B[n - 1] && getMax(n0, n1, j) == B[0]) {
                            ans += dp[n - 1][j][k];
                            ans %= MOD;
                        }
                    }
                }
            }
        }
        System.out.println(ans);
    }

    private static int getMax(int a1, int a2, int a3) {
        return Math.max(a1, Math.max(a2, a3));
    }
}
